home *** CD-ROM | disk | FTP | other *** search
/ Team Palmtops 7 / Palmtops_numero07.iso / WinCE / SDKWindowsCE / HandHeldPCPro30 / sdk.exe / Jupiter SDK / data1.cab / MFC / src / wcealt.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  1999-02-19  |  40.2 KB  |  1,423 lines
  1. // This is a part of the Microsoft Foundation Classes C++ library.
  2. // Copyright (C) 1992-1998 Microsoft Corporation
  3. // All rights reserved.
  4. //
  5. // This source code is only intended as a supplement to the
  6. // Microsoft Foundation Classes Reference and related
  7. // electronic documentation provided with the library.
  8. // See these sources for detailed information regarding the
  9. // Microsoft Foundation Classes product.
  10.  
  11. #include "stdafx.h"
  12. #include <ctype.h>
  13.  
  14. wchar_t* wce_AsciiToWide(wchar_t* ws, const char* s)
  15. {
  16.     wchar_t* pszSave = ws;
  17.     while(*s) 
  18.     {
  19.         *ws = (wchar_t) *s;
  20.         s++;
  21.         ws++;
  22.     }
  23.     *ws = 0;
  24.  
  25.     return pszSave;
  26. }
  27.  
  28. wchar_t* wce_AsciiToWide(const char* s)
  29. {
  30.     TCHAR *ws = new TCHAR[strlen(s)+1];
  31.     if(s == NULL)
  32.     {
  33.         SetLastError(ERROR_NOT_ENOUGH_MEMORY);
  34.         return NULL;
  35.     }
  36.     
  37.     return wce_AsciiToWide(ws, s);
  38. }
  39.  
  40.  
  41. int wce_wsprintfA(LPSTR szBuf, LPCSTR szFormat, UINT nArg);
  42.  
  43. // NOTE: Required by WCSTOD.OBJ in LIBC.LIB.
  44. extern "C" int WINAPI wctomb(char *s, wchar_t wchar)
  45. {
  46.     *s = (char)wchar;
  47.     return sizeof(char);
  48. }
  49.  
  50.  
  51. LPSTR wce_T2CAHelper(LPSTR lpszDest, LPCTSTR lpcszSrc)
  52. {
  53.     LPSTR lpszReturn = lpszDest;
  54.     LPTSTR lpszSrc = (LPTSTR)lpcszSrc;
  55.     if ((lpszSrc != NULL) && (lpszDest != NULL))
  56.     {
  57.         do {
  58.             *lpszDest++ = (char) *lpszSrc;
  59.         } while(*lpszSrc++);
  60.     }
  61.     return lpszReturn;
  62. }
  63.  
  64. FARPROC wce_GetProcAddress(HMODULE hModule, LPCSTR lpProcName)
  65. {
  66.     TCHAR szProcName[256] = _T("");
  67.     wce_AsciiToWide(szProcName, lpProcName);
  68.     return GetProcAddressW(hModule, szProcName);
  69. }
  70.  
  71. BOOL wce_SystemParametersInfo(UINT uiAction, UINT uiParam, PVOID pvParam, UINT fWinIni)
  72. {
  73.     ASSERT(uiAction == SPI_GETWORKAREA);
  74.     ASSERT(uiParam == NULL);
  75.     ASSERT(fWinIni == NULL);
  76.  
  77.     // making assumption that pvParam is a CRect* (see call to SystemParametersInfo in wincore.cpp)
  78.     CRect* pRect = (CRect*)pvParam; 
  79.     pRect->SetRect(0, 0, 
  80.         wce_GetSystemMetrics(SM_CXSCREEN), 
  81.         wce_GetSystemMetrics(SM_CYSCREEN));
  82.     return TRUE;
  83. }
  84.  
  85. HMODULE wce_LoadLibraryA(LPCSTR lpLibFileName)
  86. {
  87.     HMODULE hInst           = 0;
  88.     wchar_t szDLL[MAX_PATH] = _T("");
  89.  
  90.     wce_AsciiToWide(szDLL, lpLibFileName);
  91.     hInst = LoadLibraryW(szDLL);
  92.  
  93.     return (HMODULE)hInst;
  94. }                                            
  95.  
  96. BOOL wce_WinHelp(HWND hWndMain, LPCTSTR lpszHelpPath, UINT uCommand, DWORD dwData)
  97. {
  98.     TCHAR szHelpPathEx[MAX_PATH*2] = _T("");
  99.     PROCESS_INFORMATION rProcInfo;
  100.  
  101.     ASSERT(lpszHelpPath != NULL);
  102.     if (lpszHelpPath == NULL)
  103.         return FALSE;
  104.  
  105.     _tcscpy(szHelpPathEx, _T("file:"));
  106.     _tcscat(szHelpPathEx, lpszHelpPath);
  107.  
  108.     return CreateProcess(_T("PegHelp.exe"), (LPWSTR)szHelpPathEx,
  109.                NULL, NULL, FALSE, 0, NULL, NULL, NULL, &rProcInfo);
  110. }
  111.  
  112. void wce_WaitMessage()
  113. {
  114.     MSG msg;
  115.  
  116.     while(!PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE))
  117.         Sleep(100);
  118. }
  119.  
  120. // Note: we aren't handling variable arguments in this workaround.  The only 
  121. // call we're servicing is the one found in afxtrace.cpp
  122. int wce_wsprintfA(LPSTR szBuf, LPCSTR szFormat, UINT nArg)
  123. {
  124.     TCHAR *szwBuf = wce_AsciiToWide(szBuf);
  125.     TCHAR *szwFormat = wce_AsciiToWide(szFormat);
  126.     int nRetVal = 0;
  127.  
  128.     if((szwBuf != NULL) && (szwBuf != szwFormat))
  129.         nRetVal = wsprintf(szwBuf, szwFormat, nArg);
  130.  
  131.     delete [] szwBuf;
  132.     delete [] szwFormat;
  133.     return nRetVal;
  134. }
  135.  
  136. int wce_GetClipboardFormatNameA(UINT format, LPSTR lpszFormatName, int cchMaxCount)
  137. {
  138.     TCHAR *lpwszFormatName = wce_AsciiToWide(lpszFormatName);
  139.     int nRetVal = 0;
  140.  
  141.     if(lpwszFormatName != NULL)
  142.         nRetVal = GetClipboardFormatName(format, lpwszFormatName, cchMaxCount); 
  143.  
  144.     delete [] lpwszFormatName;
  145.     return nRetVal;
  146. }
  147.  
  148. BOOL wce_IsBadStringPtrA(LPCSTR lpsz, UINT ucchMax)
  149. {
  150. // WinCE: our workaround is to check to see if the first character 
  151. // and last character are readable
  152.     if(IsBadReadPtr(lpsz, 1))
  153.         return FALSE;
  154.  
  155.     int nLen = (ucchMax == -1) ? strlen(lpsz) : 
  156.         min((int)ucchMax, strlen(lpsz));
  157.     return ::IsBadReadPtr(lpsz + nLen, 1);
  158. }
  159.  
  160. BOOL wce_IsBadStringPtrW(LPCWSTR lpsz, UINT ucchMax)
  161. {
  162. // WinCE: our workaround is to check to see if the first character 
  163. // and last character are readable
  164.     if(IsBadReadPtr(lpsz, 1))
  165.         return FALSE;
  166.  
  167.     int nLen = (ucchMax == -1) ? wcslen(lpsz) : 
  168.         min((int)ucchMax, wcslen(lpsz));
  169.     return ::IsBadReadPtr(lpsz + nLen, 1);
  170. }
  171.  
  172. #if defined(_WIN32_WCE_EMULATION)
  173. extern "C" DWORD WINAPI GetCurrentDirectoryW(DWORD nBufferLength, LPTSTR lpBuffer); 
  174. BOOL wce_CheckEmulationLibs(HINSTANCE hInstance)
  175. {
  176.     TCHAR szCurrDir[MAX_PATH] = _T("");  
  177.     TCHAR szMsg[256];
  178.     HANDLE hLoadLibraryInstance;
  179.  
  180.     // Is MFC Dll in the emulation directory on the hard disk?
  181.     if(!::GetModuleFileName(hInstance, szCurrDir, _MAX_PATH))
  182.     {    
  183.         VERIFY(::GetCurrentDirectoryW(MAX_PATH, szCurrDir));  // NOTE: Previously set by emulation's COREDLL.DLL.
  184.         _stprintf(szMsg, _T("Initialization of the MFC application failed.  ")
  185.                           _T("Is the EXE or DLL in the correct emulation directory?\n(e.g. %s)"),
  186.                           szCurrDir);
  187.         ::MessageBox(NULL, szMsg, _T("Error"), MB_ICONEXCLAMATION);
  188.         return FALSE;
  189.     }
  190.  
  191.     // Is the MFC Dll in the emulation directory on the hard disk?
  192.     TCHAR* szSlash = wcsrchr(szCurrDir,'\\');
  193.     if((hLoadLibraryInstance = LoadLibrary((szSlash == NULL)?szCurrDir:szSlash+1)) == NULL)
  194.     {
  195.         _stprintf(szMsg, _T("Initialization of the MFC application failed.  ")
  196.                           _T("The MFC Dll is not in the emulation object store.\n(e.g. %s)"),
  197.                           szCurrDir);
  198.         ::MessageBox(NULL, szMsg, _T("Error"), MB_ICONEXCLAMATION);
  199.         return FALSE;
  200.     }
  201.  
  202.     return TRUE;
  203. }
  204. #endif // _WIN32_WCE_EMULATION
  205.  
  206. void wce_ReportDebugBreak(TCHAR* szFile, int nLine)
  207. {
  208.     TCHAR szBuf[100];
  209.     wsprintf(szBuf,_T("Breakpoint at %s, line %d"),szFile,nLine);
  210.     ::MessageBox(NULL,szBuf,NULL,MB_OK);
  211. }
  212.  
  213. UINT wce_GetMenuItemID(HMENU hMenu, int nPos)
  214. {    
  215.     MENUITEMINFO mii;
  216.     memset((char *)&mii, 0, sizeof(mii));
  217.     mii.cbSize = sizeof(mii); 
  218.     mii.fMask  = MIIM_ID; 
  219.     ::GetMenuItemInfo(hMenu, nPos, TRUE, &mii);
  220.  
  221.     return mii.wID; 
  222. }
  223.  
  224. HMENU wce_GetMenu(HWND hWnd)
  225. {
  226.     CWnd *pWnd = CWnd::FromHandle(hWnd);
  227.     if(pWnd == NULL)
  228.         return NULL;
  229.  
  230.     return pWnd->m_hMenu;
  231. }
  232.  
  233. BOOL wce_SetMenu(HWND hWnd, HMENU hMenu)
  234. {
  235.     CWnd *pWnd = CWnd::FromHandle(hWnd);
  236.     if(pWnd == NULL)
  237.         return FALSE;
  238.  
  239.     pWnd->m_hMenu = hMenu;
  240.     return TRUE;
  241. }
  242.  
  243. UINT wce_GetMenuState(HMENU hMenu, UINT uId, UINT uFlags)
  244. {
  245.     MENUITEMINFO mii;
  246.  
  247.     memset((char *)&mii, 0, sizeof(MENUITEMINFO));
  248.     mii.cbSize = sizeof(MENUITEMINFO);
  249.     mii.fMask  = MIIM_ID;
  250.  
  251.     if (uFlags & MF_BYPOSITION)
  252.         ::GetMenuItemInfo(hMenu, uId, TRUE, &mii);
  253.     else
  254.         ::GetMenuItemInfo(hMenu, uId, FALSE, &mii);
  255.  
  256.     return mii.fState;
  257. }
  258.  
  259. BOOL wce_ModifyMenu(HMENU   hMenu,      // handle of menu 
  260.                      UINT    uPosition,  // menu item to modify 
  261.                      UINT    uFlags,     // menu item flags 
  262.                      UINT    uIDNewItem, // menu item identifier or handle of drop-down menu or submenu 
  263.                      LPCTSTR lpNewItem) // menu item content 
  264. {
  265.     // Handle MF_BYCOMMAND case
  266.     if ((uFlags & MF_BYPOSITION) != MF_BYPOSITION)
  267.     {    
  268.         int nMax = wce_GetMenuItemCount(hMenu);
  269.         int nCount = 0;
  270.         while (uPosition != wce_GetMenuItemID(hMenu, nCount) && (nCount < nMax))
  271.             nCount++;
  272.         ASSERT(nCount < nMax);
  273.         uPosition = nCount;
  274.         uFlags |= MF_BYPOSITION;
  275.     }
  276.  
  277.     if (!::DeleteMenu(hMenu, uPosition, uFlags))
  278.         return FALSE;
  279.  
  280.     return ::InsertMenu(hMenu, uPosition, uFlags, uIDNewItem, lpNewItem);
  281. }
  282.  
  283. int wce_GetMenuItemCount(HMENU hMenu)
  284. {
  285.     const int MAX_NUM_ITEMS = 256;
  286.     int  iPos, iCount;
  287.  
  288.     MENUITEMINFO mii;
  289.     memset((char *)&mii, 0, sizeof(MENUITEMINFO));
  290.     mii.cbSize = sizeof(MENUITEMINFO);
  291.  
  292.     iCount = 0;
  293.     for (iPos = 0; iPos < MAX_NUM_ITEMS; iPos++)
  294.     {
  295.         if(!GetMenuItemInfo(hMenu, (UINT)iPos, TRUE, &mii))
  296.             break;
  297.         iCount++;
  298.     }
  299.  
  300.     return iCount;
  301. }
  302.  
  303. int wce_GetMenuString(HMENU hMenu, UINT uIDItem, LPWSTR lpString, int nMaxCount, UINT uFlag)
  304. { 
  305.     MENUITEMINFO mii;
  306.     memset((char *)&mii, 0, sizeof(MENUITEMINFO));
  307.     mii.cbSize = sizeof(MENUITEMINFO);
  308.  
  309.     if (!GetMenuItemInfo(hMenu, 0, TRUE, &mii))
  310.         return 0;
  311.     
  312.     mii.fMask      = MIIM_TYPE;  // to get dwTypeData
  313.     mii.fType      = MFT_STRING; // to get dwTypeData
  314.     mii.dwTypeData = lpString;
  315.     mii.cch        = nMaxCount;
  316.  
  317.     if (uFlag == MF_BYPOSITION)
  318.         ::GetMenuItemInfo(hMenu, uIDItem, TRUE, &mii);
  319.     else
  320.     {
  321.         ASSERT(uFlag == MF_BYCOMMAND);
  322.         ::GetMenuItemInfo(hMenu, uIDItem, FALSE, &mii);
  323.     }
  324.  
  325.     if (mii.dwTypeData != NULL)
  326.         return _tcslen(lpString);
  327.  
  328.     return 0;
  329. }
  330.  
  331. HPEN wce_CreatePen(int nPenStyle, int nWidth, COLORREF crColor)
  332. { 
  333.     LOGPEN logPen;
  334.     
  335.     if(nPenStyle == PS_DOT)
  336.         nPenStyle = PS_DASH;
  337.     logPen.lopnStyle   = nPenStyle;
  338.     if(nWidth == 0)
  339.         nWidth = 1;
  340.     logPen.lopnWidth.x = nWidth;
  341.     logPen.lopnWidth.y = 1;
  342.     logPen.lopnColor   = crColor;
  343.  
  344.     return ::CreatePenIndirect(&logPen); 
  345. }
  346.  
  347. HBRUSH wce_CreateBrushIndirect(const LOGBRUSH* lplb)
  348. {
  349.     if (lplb->lbStyle == BS_SOLID)
  350.         return ::CreateSolidBrush(lplb->lbColor);
  351.     if (lplb->lbStyle == BS_NULL)    
  352.         return (HBRUSH)::GetStockObject(NULL_BRUSH);
  353.     if (lplb->lbStyle == BS_DIBPATTERNPT)
  354.     {
  355.         ASSERT(lplb->lbColor == DIB_RGB_COLORS);
  356.         return ::CreateDIBPatternBrushPt((void*)lplb->lbHatch, lplb->lbColor);
  357.     }
  358.     TRACE0("LOGBRUSH style member is invalid");
  359.     return NULL;
  360. }
  361.  
  362. HFONT wce_CreateFont(int nHeight, int nWidth, int nEscapement,
  363.         int nOrientation, int nWeight, BYTE bItalic, BYTE bUnderline,
  364.         BYTE cStrikeOut, BYTE nCharSet, BYTE nOutPrecision,
  365.         BYTE nClipPrecision, BYTE nQuality, BYTE nPitchAndFamily,
  366.         LPCTSTR lpszFacename)
  367. {
  368.     LOGFONT logFont;
  369.     logFont.lfHeight = nHeight;
  370.     logFont.lfWidth = nWidth;
  371.     logFont.lfEscapement = nEscapement;
  372.     logFont.lfOrientation = nOrientation;
  373.     logFont.lfWeight = nWeight;
  374.     logFont.lfItalic = bItalic;
  375.     logFont.lfUnderline = bUnderline;
  376.     logFont.lfStrikeOut = cStrikeOut;
  377.     logFont.lfCharSet = nCharSet;
  378.     logFont.lfOutPrecision = nOutPrecision;
  379.     logFont.lfClipPrecision = nClipPrecision;
  380.     logFont.lfQuality = nQuality;
  381.     logFont.lfPitchAndFamily = nPitchAndFamily;
  382.     lstrcpyn(logFont.lfFaceName, lpszFacename, _countof(logFont.lfFaceName));
  383.  
  384.     return ::CreateFontIndirect(&logFont);
  385. }
  386.  
  387. HRGN wce_CreateRectRgn(int x1, int y1, int x2, int y2)
  388. {
  389.     CRect rect(x1,y1,x2,y2);
  390.     return ::CreateRectRgnIndirect(&rect); 
  391. }
  392.  
  393. BOOL wce_SetRectRgn(HRGN hrgn, int nLeftRect, int nTopRect, int nRightRect, int nBottomRect)
  394. {
  395.     BOOL bRetVal = TRUE;
  396.     HRGN hrgnCopy;
  397.     hrgnCopy = ::wce_CreateRectRgn(nLeftRect, nTopRect, nRightRect, nBottomRect); 
  398.     if (hrgnCopy == NULL)
  399.         return FALSE;
  400.     if (::CombineRgn(hrgn, hrgnCopy, NULL, RGN_COPY) == ERROR)
  401.         bRetVal = FALSE;
  402.     ::DeleteObject(hrgnCopy);
  403.     return bRetVal;
  404. }
  405.  
  406. BOOL wce_GetBrushOrgEx(HDC hdc, LPPOINT lppt)
  407. {
  408.     if (::SetBrushOrgEx(hdc, 0, 0, lppt) == FALSE)
  409.         return FALSE;
  410.     return ::SetBrushOrgEx(hdc, lppt->x, lppt->y, NULL);
  411. }
  412.  
  413. int wce_OffsetClipRgn(HDC hdc, int nXOffset, int nYOffset)
  414. {
  415.     int nRetVal;
  416.     HRGN hrgn;
  417.     hrgn = ::wce_CreateRectRgn(0,0,1,1); 
  418.     if (::GetClipRgn(hdc, hrgn) == -1)
  419.         nRetVal = ERROR;
  420.     else
  421.     {
  422.         if (::OffsetRgn(hrgn, nXOffset, nYOffset) == ERROR)
  423.             nRetVal = ERROR;
  424.         else
  425.             nRetVal = ::SelectClipRgn(hdc,hrgn);    
  426.     }
  427.     ::DeleteObject(hrgn);
  428.     return nRetVal;
  429. }
  430.  
  431. int wce_ExtSelectClipRgn(HDC hdc, HRGN hrgn, int fnMode)
  432. {
  433.     ASSERT((hrgn != NULL) || (fnMode == RGN_COPY));
  434.     int nRetVal;
  435.     if (fnMode == RGN_COPY)
  436.         nRetVal = ::SelectClipRgn(hdc, hrgn);    
  437.     else
  438.     {
  439.         HRGN hrgnClip;
  440.         hrgnClip = ::wce_CreateRectRgn(0,0,1,1); 
  441.         if (::GetClipRgn(hdc, hrgnClip) == -1)
  442.             nRetVal = ERROR;
  443.         else 
  444.         {
  445.             if (::CombineRgn(hrgnClip, hrgnClip, hrgn, fnMode) == ERROR)
  446.                 nRetVal = ERROR;
  447.             else 
  448.                 nRetVal = ::SelectClipRgn(hdc, hrgnClip);
  449.         }
  450.         ::DeleteObject(hrgnClip);
  451.     }
  452.     return nRetVal;
  453. }
  454.  
  455. int wce_ExcludeUpdateRgn(HDC hDC, HWND hWnd)
  456. {
  457.     int nRetVal;
  458.     HRGN hrgn;
  459.     hrgn = ::wce_CreateRectRgn(0,0,1,1); 
  460.     nRetVal = ::GetUpdateRgn(hWnd, hrgn, FALSE);
  461.     if (nRetVal != ERROR)
  462.     {
  463.         if (::wce_ExtSelectClipRgn(hDC, hrgn, RGN_DIFF) == ERROR)
  464.             nRetVal = ERROR;
  465.     }
  466.     ::DeleteObject(hrgn);
  467.     return nRetVal;
  468. }
  469.  
  470. BOOL wce_PolyPolyline(HDC hdc, const POINT* lppt, const DWORD* lpdwPolyPoints, DWORD cCount)
  471. {
  472.     if (cCount < 0)
  473.         return FALSE;
  474.     BOOL bResult = TRUE;
  475.     int startIndex = 0;
  476.     for (DWORD i=0; i < cCount && bResult; i++) 
  477.     {
  478.         ASSERT(lpdwPolyPoints[i] >= 2);
  479.         bResult = ::Polyline(hdc, &(lppt[startIndex]), lpdwPolyPoints[i]);
  480.         startIndex += lpdwPolyPoints[i]; // jump to next polyline
  481.     }
  482.     return bResult;
  483. }
  484.  
  485. BOOL wce_PolyPolygon(HDC hdc, const POINT* lpPoints, const int* lpPolyCounts, int nCount)
  486. {
  487.     if (nCount < 2)
  488.         return FALSE;
  489.     BOOL bResult = TRUE;
  490.     int startIndex = 0;
  491.     for (int i=0; i < nCount && bResult; i++) 
  492.     {
  493.         ASSERT(lpPolyCounts[i] >= 2);
  494.         bResult = ::Polygon(hdc, &(lpPoints[startIndex]), lpPolyCounts[i]);
  495.         startIndex += lpPolyCounts[i]; // jump to next polygon
  496.     }
  497.     return bResult;
  498. }
  499.  
  500. int wce_FrameRect(HDC hdc, const RECT* lprc, HBRUSH hbr)
  501. {
  502.     // Fill a "line-size" rectangle for each edge of the frame, using hbr
  503.     // Note that right/bottom borders not painted by FillRect (or FrameRect)
  504.     RECT rectEdge;    
  505.     if (::SetRect(&rectEdge, lprc->left, lprc->top, lprc->right, 
  506.                   lprc->top + 1) == FALSE) // Top edge of frame
  507.         return FALSE;
  508.     if (::FillRect(hdc, &rectEdge, hbr) == FALSE)
  509.         return FALSE;
  510.     
  511.     if (::SetRect(&rectEdge, lprc->right - 1, lprc->top, lprc->right, 
  512.                   lprc->bottom) == FALSE) // Right edge of frame
  513.         return FALSE;
  514.     if (::FillRect(hdc, &rectEdge, hbr) == FALSE)
  515.         return FALSE;
  516.     if (::SetRect(&rectEdge, lprc->left, lprc->bottom - 1, lprc->right, 
  517.                   lprc->bottom) == FALSE) // Bottom edge of frame
  518.         return FALSE;
  519.     if (::FillRect(hdc, &rectEdge, hbr) == FALSE)
  520.         return FALSE;
  521.     if (::SetRect(&rectEdge, lprc->left, lprc->top, lprc->left + 1, 
  522.                   lprc->bottom) == FALSE) // Left edge of frame
  523.         return FALSE;
  524.     return ::FillRect(hdc, &rectEdge, hbr);
  525. }
  526.  
  527. LONG wce_RegCreateKey(HKEY hKey, LPCWSTR lpSubKey, PHKEY phkResult)
  528. {
  529.     long lResult = 0;
  530.     DWORD dwDisposition = 0;
  531.  
  532.     lResult = RegCreateKeyExW(hKey, lpSubKey, 0, NULL, NULL, KEY_ALL_ACCESS, NULL, 
  533.                               phkResult, &dwDisposition);
  534.     return lResult;
  535. }
  536.  
  537. LONG wce_RegQueryValue(HKEY hKey, LPCWSTR lpRegValue, LPWSTR lpValue, PLONG lpcbValue)
  538. {
  539.     long  lResult     = 0;
  540.     DWORD dwValueType = 0;
  541.  
  542.     lResult = RegQueryValueExW((HKEY)hKey, (LPTSTR)lpRegValue, (LPDWORD)NULL, 
  543.         (LPDWORD)&dwValueType, (LPBYTE)lpValue, (LPDWORD)lpcbValue);
  544.     return lResult;
  545. }
  546.  
  547. LONG wce_RegOpenKey(HKEY     hKey,            // handle of open key 
  548.                      LPCTSTR  lpSubKey,        // address of name of subkey to open 
  549.                      PHKEY  phkResult)     // address of handle of open key 
  550. {
  551.     long lResult = 0;
  552.     HANDLE hBuffer = NULL;
  553.  
  554.     lResult = RegOpenKeyExW(hKey, lpSubKey, 0, KEY_ALL_ACCESS, phkResult);
  555.     if(lResult == ERROR_SUCCESS)
  556.         return lResult;
  557.  
  558.     // Workaround:  the KEY_ALL_ACCESS above contains KEY_CREATE_SUB_KEY, except
  559.     // that it's not supported in WinCE.  So if an error results, check to see if its
  560.     // a value that's meant to be converted to a key (which is the behavior of the 
  561.     // desktop RegOpenKey()).
  562.  
  563.     BYTE *lpBuffer;
  564.     DWORD dwType;
  565.     DWORD dwSize;
  566.     long lPrevResult = lResult;
  567.     
  568.     lResult = RegQueryValueEx(hKey, lpSubKey, 0, &dwType, NULL, &dwSize);
  569.     if(lResult != ERROR_SUCCESS)
  570.         return lResult;
  571.  
  572.     ASSERT(dwSize > 0);
  573.     hBuffer = LocalAlloc(LMEM_FIXED, dwSize);
  574.     if(hBuffer == NULL)
  575.         return ERROR_NOT_ENOUGH_MEMORY;
  576.  
  577.     lpBuffer = (BYTE*)WCE_FCTN(GlobalLock)(hBuffer);
  578.     lResult = RegQueryValueEx(hKey, lpSubKey, 0, &dwType, lpBuffer, &dwSize);
  579.     if(lResult != ERROR_SUCCESS)
  580.     {
  581.         lResult = lPrevResult;
  582.         goto wceROK_ERROR;
  583.     }
  584.  
  585.     lResult = RegDeleteValue(hKey, lpSubKey);
  586.     if(lResult != ERROR_SUCCESS)
  587.     {
  588.         lResult = lPrevResult;
  589.         goto wceROK_ERROR;
  590.     }
  591.  
  592.     DWORD dwDisposition;
  593.     lResult = RegCreateKeyEx(hKey, lpSubKey, 0, NULL, NULL, KEY_ALL_ACCESS, NULL, 
  594.                              phkResult, &dwDisposition);
  595.     if(lResult != ERROR_SUCCESS)
  596.     {
  597.         lResult = lPrevResult;
  598.         goto wceROK_ERROR;
  599.     }
  600.  
  601.     lResult = RegSetValueEx(*phkResult, lpSubKey, 0, dwType, lpBuffer, dwSize);
  602.     if(lResult != ERROR_SUCCESS)
  603.     {
  604.         lResult = lPrevResult;
  605.         goto wceROK_ERROR;
  606.     }
  607.  
  608. wceROK_ERROR:
  609.     if(hBuffer != NULL)
  610.     {
  611.         LocalLock(hBuffer);
  612.         LocalFree(hBuffer);
  613.     }
  614.  
  615.     return lResult;
  616.  
  617. }
  618.  
  619. // RegSetValueEx is used as a workaround  for RegSetValue, but is not behaviorally
  620. // equivalent. If the specified key doesn't exist and it's not a value, RegSetValue 
  621. // creates a key, and applies the value to it.  
  622. // RegSetValueEx doesn't do this, it rather creates another value under the specified
  623. // prarent key.  Our override is to detect this circumstance, and creating a key
  624. // manually before calling RegSetValueEx.
  625. // Note: this workaround does not claim to be equivalent to RegSetValue.
  626. LONG wce_RegSetValue(HKEY hKey, LPCTSTR lpSubKey, DWORD dwType, LPCTSTR lpData,  
  627.                      DWORD cbData)
  628. {
  629.     LONG lResult;
  630.     HKEY hSubKey;
  631.  
  632.     // If lpSubKey is NULL or an empty string, just delegate to the Ex function
  633.     if((lpSubKey == NULL) || (*lpSubKey == _T('\0')))
  634.     {
  635.         return RegSetValueEx(hKey, lpSubKey, 0 /*reserved*/, dwType,
  636.             (CONST BYTE*)lpData, (cbData + 1) * sizeof(TCHAR));
  637.     }
  638.  
  639.     // NOTE: in the following, we do not want to pass in KEY_CREATE_SUB_KEY (nevermind the
  640.     // fact that that particular flag isn't supported in WinCE 2.0).  We just want to do a 
  641.     // test and don't want an automatic conversion from a value to a key.
  642.     lResult = RegOpenKeyEx(hKey, lpSubKey, 0, 0, &hSubKey);
  643.     if(lResult != ERROR_SUCCESS) 
  644.     {    // it's not a key, so it's either a value or emptiness. So that means another test. 
  645.         DWORD dwType,dwSize;
  646.         lResult = RegQueryValueEx(hKey, lpSubKey, 0, &dwType, NULL, &dwSize);
  647.         if(lResult == ERROR_SUCCESS) // it's a value
  648.         {
  649.             // We can call RegSetValueEx now because we want to keep it as a value
  650.             return RegSetValueEx(hKey, lpSubKey, 0 /*reserved*/, dwType,
  651.                 (CONST BYTE*)lpData, (cbData + 1) * sizeof(TCHAR));
  652.         }
  653.         else // We have emptiness... create a key
  654.         {
  655.             DWORD dwDisposition;
  656.             lResult = RegCreateKeyEx(hKey, lpSubKey, 0, NULL, NULL, KEY_ALL_ACCESS, NULL, 
  657.                                      &hSubKey, &dwDisposition);
  658.             if(lResult != ERROR_SUCCESS)
  659.                 return lResult;
  660.         }
  661.     }
  662.  
  663.     // At this point, we have a hSubKey.  Set its default value.  
  664.     // This can only be done with strings.
  665.     ASSERT(dwType == REG_SZ);
  666.     return RegSetValueEx(hSubKey, _T(""), 0 /*reserved*/, dwType,
  667.         (CONST BYTE*)lpData, (cbData + 1) * sizeof(TCHAR));
  668. }
  669.  
  670.  
  671. LONG wce_RegEnumKey(HKEY    hKey,        // handle of key to query 
  672.                      DWORD   dwIndex,    // index of subkey to query 
  673.                      LPTSTR  lpName,    // address of buffer for subkey name  
  674.                      DWORD   cbName)    // size of subkey buffer 
  675. {
  676.     long      lResult;
  677.     FILETIME  rFileTime;
  678.  
  679.     lResult = RegEnumKeyExW(hKey, dwIndex, lpName, &cbName, NULL, NULL,
  680.                             NULL, &rFileTime);
  681.     return lResult;
  682. }
  683.  
  684.  
  685. // Returns key for HKEY_CURRENT_USER\"Software"\RegistryKey\ProfileName,
  686. // creating it if it doesn't exist.
  687. // Responsibility of the caller to call RegCloseKey() on the returned HKEY.
  688. // INI strings are not localized.
  689. static const TCHAR szSoftware[]    = _T("\\Software");
  690. static const TCHAR szRegistryKey[] = _T("Microsoft\\MFC_WCE");
  691. static const TCHAR szProfileName[] = _T("afx.ini");
  692. HKEY wce_GetAppRegistryKey()
  693. {
  694.     HKEY hAppKey     = NULL;
  695.     HKEY hSoftKey    = NULL;
  696.     HKEY hCompanyKey = NULL;
  697.     long lResult     = 0;
  698.  
  699.     if (RegOpenKeyEx(HKEY_CURRENT_USER, szSoftware, 0, KEY_ALL_ACCESS, &hSoftKey) == ERROR_SUCCESS)
  700.     {
  701.         DWORD dw;
  702.         if (RegCreateKeyEx(hSoftKey, szRegistryKey, 0, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
  703.             &hCompanyKey, &dw) == ERROR_SUCCESS)
  704.         {
  705.             long lResult = RegCreateKeyEx(hCompanyKey, szProfileName, 0, REG_NONE, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL,
  706.                 &hAppKey, &dw);
  707.             ASSERT(lResult == ERROR_SUCCESS);
  708.         }
  709.         else
  710.             ASSERT(FALSE);
  711.     }
  712.     if (hSoftKey != NULL)
  713.     {
  714.         lResult = RegCloseKey(hSoftKey);
  715.         ASSERT(lResult == ERROR_SUCCESS);
  716.     }
  717.     if (hCompanyKey != NULL)
  718.     {
  719.         lResult = RegCloseKey(hCompanyKey);
  720.         ASSERT(lResult == ERROR_SUCCESS);
  721.     }
  722.  
  723.     return hAppKey;
  724. }
  725.  
  726.  
  727. // Returns key for:
  728. //      HKEY_CURRENT_USER\"Software"\RegistryKey\AppName\lpszSection
  729. // creating it if it doesn't exist.
  730. // Responsibility of the caller to call RegCloseKey() on the returned HKEY.
  731. HKEY wce_GetSectionKey(LPCTSTR lpszSection)
  732. {
  733.     long lResult = 0;
  734.  
  735.     ASSERT(lpszSection != NULL);
  736.  
  737.     HKEY hSectionKey = NULL;
  738.     HKEY hAppKey = wce_GetAppRegistryKey();
  739.     if (hAppKey == NULL)
  740.         return NULL;
  741.  
  742.     DWORD dw;
  743.     lResult = RegCreateKeyEx(hAppKey, lpszSection, 0, REG_NONE,
  744.         REG_OPTION_NON_VOLATILE, KEY_WRITE|KEY_READ, NULL,
  745.         &hSectionKey, &dw);
  746.     ASSERT(lResult == ERROR_SUCCESS);
  747.  
  748.     lResult = RegCloseKey(hAppKey);
  749.     ASSERT(lResult == ERROR_SUCCESS);
  750.  
  751.     return hSectionKey;
  752. }
  753.  
  754.  
  755.  
  756. UINT wce_GetSystemDirectory(LPWSTR lpBuffer, UINT uSize)
  757. { 
  758.     wcscpy(lpBuffer, _T("\\WINDOWS")); 
  759.     return (UINT)wcslen(lpBuffer); 
  760. }
  761.  
  762. UINT wce_GetSystemDirectoryA(LPSTR lpBuffer, UINT uSize)
  763. {
  764.         strcpy(lpBuffer,    "\\WINDOWS" );
  765.         return (UINT)strlen(lpBuffer);
  766. }
  767.  
  768. TCHAR* wce_GetNextArg(TCHAR* pszArgList, TCHAR szArg[])
  769. {
  770.  
  771.     TCHAR*  pszSpace     = NULL;
  772.     TCHAR*  pszTab       = NULL;
  773.     TCHAR*  pszNextArg   = NULL;
  774.     LPTSTR  pszArg       = &szArg[0];
  775.     int     iWhiteCount  = 0;
  776.  
  777.     if ((pszArgList == NULL) || (lstrlen(pszArgList) == 0))
  778.         return NULL;
  779.  
  780.     // count white space
  781.     iWhiteCount = 0;
  782.     pszSpace    = &pszArgList[0];
  783.     while ((*pszSpace++ == (short)' ') || (*pszSpace++ == (short)'\t'))
  784.         iWhiteCount++;
  785.  
  786.     // copy next arg to szArg
  787.     lstrcpy(szArg, &pszArgList[iWhiteCount]);
  788.     pszArg = &szArg[0];
  789.  
  790.     // null-terminate it
  791.     // point pszNextArg at next arg
  792.     pszSpace = _tcschr(szArg, (int)' ');
  793.     pszTab   = _tcschr(szArg, (int)'\t');
  794.     if ((pszSpace == NULL) && (pszTab != NULL))
  795.     {
  796.         pszSpace = pszTab;
  797.     }
  798.     else if ((pszSpace != NULL) && (pszTab != NULL))
  799.     {
  800.         if (pszTab < pszSpace)
  801.             pszSpace = pszTab;
  802.     }
  803.     if (pszSpace)
  804.     {
  805.         *pszSpace = 0;
  806.         pszNextArg = pszSpace + 1;
  807.     }
  808.     else
  809.         pszNextArg = &szArg[lstrlen(szArg)+1];
  810.  
  811.     ASSERT(pszArg != NULL);
  812.  
  813.     // return pointer to beginning of next arg in list
  814.     return pszNextArg;
  815. }
  816.  
  817.  
  818. int wce_GetArgCount(TCHAR* pszArgList)
  819. {
  820.  
  821.     TCHAR*  pszSpace     = NULL;
  822.     TCHAR*  pszTab       = NULL;
  823.     TCHAR*  pszNextArg   = NULL;
  824.     int     iWhiteCount  = 0;
  825.     int     iArgCount    = 0;
  826.  
  827.     if ((pszArgList == NULL) || (lstrlen(pszArgList) == 0))
  828.         return 0;
  829.  
  830.     iArgCount  = 0;
  831.     pszNextArg = pszArgList;
  832.     while (pszNextArg != NULL)
  833.     {
  834.         // gobble/count white space
  835.         iWhiteCount = 0;
  836.         pszSpace    = pszNextArg;
  837.         while ((*pszSpace++ == (short)' ') || (*pszSpace++ == (short)'\t'))
  838.             iWhiteCount++;
  839.         // point pszNextArg past the white space
  840.         pszNextArg = &pszNextArg[iWhiteCount];
  841.         // if its not null, then increment the count
  842.         if (pszNextArg != NULL)
  843.             iArgCount++;
  844.         // for next iteration, point pszNextArg at next arg
  845.         pszSpace = _tcschr(pszNextArg, (int)' ');
  846.         pszTab   = _tcschr(pszNextArg, (int)'\t');
  847.         if ((pszSpace == NULL) && (pszTab != NULL))
  848.         {
  849.             pszSpace = pszTab;
  850.         }
  851.         else if ((pszSpace != NULL) && (pszTab != NULL))
  852.         {
  853.             if (pszTab < pszSpace)
  854.                 pszSpace = pszTab;
  855.         }
  856.         if (pszSpace)
  857.             pszNextArg = pszSpace + 1;
  858.         else
  859.             break;  // i.e. we're done
  860.     }
  861.  
  862.     return iArgCount;
  863. }
  864.  
  865. BOOL wce_ArgvW(int argc, char* argv[])
  866. {
  867.     TCHAR szTmp[MAX_PATH*2] = _T("");
  868.  
  869.     if (!argv)
  870.         return TRUE;
  871.  
  872.     for (int i = 0; i < argc; i++)
  873.     {
  874.         if (argv[i])
  875.         {
  876.             // Convert the char* to wchar_t*.
  877.             wce_AsciiToWide(szTmp, argv[i]);
  878.             // Free the previous pointer.
  879.             free(argv[i]);
  880.             // Reset argv[i] to point at the wchar_t*.
  881.             argv[i] = (char*)_tcsdup(szTmp);
  882.             ASSERT(argv[i] != NULL);
  883.             if (!argv[i])
  884.                 return FALSE;
  885.         }
  886.     }
  887.  
  888.     return TRUE;
  889. }
  890.  
  891. DWORD wce_GetObjectStoreFreeSpace()
  892. { 
  893.     STORE_INFORMATION stinfo;
  894.     
  895.     if (GetStoreInformation(&stinfo))
  896.         return stinfo.dwFreeSize;
  897.  
  898.     return 0;
  899. }
  900.  
  901. short wce_GetFileTitleW(LPCTSTR lpszFile,    // pointer to full path and filename for file
  902.                          LPTSTR  lpszTitle,   // pointer to buffer that receives filename
  903.                          WORD cbBuf)         // length of buffer
  904. {
  905.     TCHAR* pszSlashPlus1     = 0;
  906.     int    iLen              = 0;
  907.  
  908.     if ((lpszFile == NULL) || (_tcslen(lpszFile)==0))
  909.         return -1;
  910.  
  911.     // Find last backslash (if present).
  912.     // Point at first char after last backslash.
  913.     pszSlashPlus1 = _tcsrchr(lpszFile, (int)'\\');
  914.     if (pszSlashPlus1 == NULL)
  915.         pszSlashPlus1 = (TCHAR*)lpszFile;
  916.     else
  917.         pszSlashPlus1 = pszSlashPlus1 + 1;
  918.  
  919.     // Compute the length of new string and compare with cbBuf.
  920.     iLen = _tcslen(pszSlashPlus1);
  921.     if (iLen > (int)cbBuf)
  922.         return -1;
  923.  
  924.     // Copy basename to lpszTitle.
  925.     _tcscpy(lpszTitle, pszSlashPlus1);
  926.  
  927.     return 0;
  928. }
  929.  
  930.  
  931. UINT wce_GetTempFileName(LPCTSTR lpszPathName,       // address of directory name for temporary file
  932.                           LPCTSTR lpszPrefixString,   // address of filename prefix
  933.                           UINT      uUnique,              // dummy
  934.                           LPTSTR  lpszTempFileName)  // address of buffer that receives the new filename
  935. {
  936.     TCHAR szPathNameCopy[_MAX_PATH] = _T("");
  937.  
  938.     uUnique = uUnique;
  939.  
  940.     // Remove trailing backslash.
  941.     // NOTE: Make copy of lpszPathName (since we may need to modify it).
  942.     _tcscpy(szPathNameCopy, lpszPathName);
  943.     int iLen = _tcslen(szPathNameCopy);
  944.     if (szPathNameCopy[iLen-1] == _T('\\'))
  945.         szPathNameCopy[iLen-1] = _T('\0');
  946.  
  947.     // Check for duplicates. If a file with the resulting filename exists, the number is 
  948.     // increased by one and the test for existence is repeated. Testing continues until a 
  949.     // unique filename is found.
  950.     
  951.     CFileStatus status;
  952.     time_t lnSecsSuffix = wce_time(NULL) & 0x000FFFFF;
  953.  
  954.     do {
  955.         wsprintf(lpszTempFileName, _T("%s\\%s%5X.tmp"), szPathNameCopy, lpszPrefixString, 
  956.                    lnSecsSuffix);
  957.         ++lnSecsSuffix;
  958.     } while (CFile::GetStatus(lpszTempFileName, status));
  959.         
  960.     lnSecsSuffix--;
  961.     return (UINT)lnSecsSuffix;
  962. }
  963.  
  964.  
  965. DWORD wce_GetFullPathName(LPCTSTR lpFileName, DWORD nBufferLength, LPWSTR lpBuffer, LPWSTR* lppFilePart)
  966. {
  967.     ASSERT(AfxIsValidString(lpFileName));
  968.     ASSERT(lppFilePart != NULL);
  969.  
  970.     int nLen = _tcslen(lpFileName);
  971.     ASSERT(AfxIsValidAddress(lpBuffer, nLen, TRUE));
  972.     _tcscpy(lpBuffer, lpFileName);
  973.  
  974.     LPTSTR lpszSlash = _tcsrchr(lpBuffer, (int)'\\');
  975.     if (lpszSlash == NULL)
  976.         *lppFilePart = lpBuffer;
  977.     else
  978.         *lppFilePart = lpszSlash+1;
  979.  
  980.     return (DWORD)nLen;
  981. }
  982.  
  983. BOOL wce_GetScrollRange(HWND hWnd, int nBar, LPINT lpMinPos, LPINT lpMaxPos)
  984. { 
  985.     SCROLLINFO si;
  986.  
  987.     memset( &si, 0, sizeof(SCROLLINFO) );
  988.     si.cbSize = sizeof(SCROLLINFO);
  989.     si.fMask  = SIF_RANGE;
  990.  
  991.     if(!GetScrollInfo( hWnd, nBar, &si))
  992.         return (FALSE);
  993.  
  994.     *lpMinPos = si.nMin;
  995.     *lpMaxPos = si.nMax;
  996.  
  997.     return TRUE; 
  998. }
  999.  
  1000. int wce_GetScrollPos( HWND hWnd, int nBar)
  1001. { 
  1002.     BOOL       bIsOK = FALSE;
  1003.     SCROLLINFO si;
  1004.  
  1005.     memset(&si, 0, sizeof(SCROLLINFO));
  1006.     si.cbSize = sizeof(SCROLLINFO);
  1007.     si.fMask  = SIF_POS;
  1008.  
  1009.     if(!GetScrollInfo(hWnd, nBar, &si))
  1010.         return 0;
  1011.  
  1012.     return si.nPos; 
  1013. }
  1014.  
  1015. void wce_ScrollChildren(HWND hWnd, int cx, int cy)
  1016. {
  1017.     // WinCE does not perform any scrolling if the window is
  1018.     // not visible.  This leaves child windows unscrolled.
  1019.     // To account for this oversight, the child windows are moved
  1020.     // directly instead.
  1021.     HWND hWndChild = ::GetWindow(hWnd, GW_CHILD);
  1022.     if (hWndChild != NULL)
  1023.     {
  1024.         for (; hWndChild != NULL;
  1025.             hWndChild = ::wce_GetNextWindow(hWndChild, GW_HWNDNEXT))
  1026.         {
  1027.             RECT rect;
  1028.             ::GetWindowRect(hWndChild, &rect);
  1029.             ::ScreenToClient(hWnd,(POINT*)&rect.left);
  1030.             ::SetWindowPos(hWndChild, NULL,    rect.left-cx, rect.top-cy,
  1031.                 0, 0, SWP_NOSIZE|SWP_NOACTIVATE|SWP_NOZORDER);
  1032.         }
  1033.     }
  1034. }
  1035.  
  1036.  
  1037. // Added the following workaround for InvalidateRgn.
  1038. BOOL wce_InvalidateRgn(HWND hWnd, HRGN hRgn, BOOL bErase)
  1039. {
  1040.     BOOL bReturn;
  1041.     HDC hdc = ::GetDC(hWnd);
  1042.     if(hdc == NULL) // if no DC, just erase the whole thing
  1043.         bReturn = ::InvalidateRect(hWnd,NULL,bErase);
  1044.     else
  1045.     {
  1046.         // Using the DC, get the smallest rectangle that encloses the region.
  1047.         RECT rect;
  1048.         SelectObject(hdc,hRgn);
  1049.         ::GetClipBox(hdc,&rect);
  1050.         bReturn = ::InvalidateRect(hWnd,&rect,bErase);
  1051.         ::ReleaseDC(hWnd,hdc);
  1052.     }
  1053.  
  1054.     return bReturn;
  1055. }
  1056.  
  1057. BOOL wce_EnumChildWindows( HWND hWndParent, WNDENUMPROC lpEnumFunc, LPARAM lParam )
  1058. {
  1059.     if (hWndParent == NULL)
  1060.             return (FALSE);
  1061.  
  1062.     HWND hWndChild = ::GetWindow( hWndParent, GW_CHILD );
  1063.     for (; hWndChild != NULL; hWndChild = ::wce_GetNextWindow(hWndChild, GW_HWNDNEXT))
  1064.     {
  1065.         lpEnumFunc( hWndChild, lParam );
  1066.         wce_EnumChildWindows( hWndChild, lpEnumFunc, lParam );
  1067.     }
  1068.  
  1069.     return (TRUE);
  1070. }
  1071.  
  1072. BOOL wce_RedrawWindow(HWND hWnd, CONST RECT *prcUpdate, HRGN hrgnUpdate, UINT afuRedraw)
  1073. {
  1074.     ::InvalidateRect(hWnd, prcUpdate, afuRedraw & RDW_ERASE ? TRUE : FALSE);
  1075.     if ((afuRedraw & RDW_ERASENOW) || (afuRedraw & RDW_UPDATENOW)) 
  1076.         ::UpdateWindow(hWnd);
  1077.     return TRUE;
  1078. }
  1079.  
  1080. BOOL wce_ShowScrollBar(HWND hWnd, int nBar, BOOL bShow)
  1081. {
  1082. // WinCE: this workaround doesn't work with x86em
  1083. #if defined(_WIN32_WCE_EMULATION)
  1084.     return TRUE;
  1085. #else // _WIN32_WCE_EMULATION
  1086.     DWORD dwStyle = ::GetWindowLong(hWnd, GWL_STYLE);
  1087.     if(bShow)
  1088.         dwStyle |= ((nBar == SB_HORZ) ? WS_HSCROLL : WS_VSCROLL);
  1089.     else
  1090.         dwStyle &= ~((nBar == SB_HORZ) ? WS_HSCROLL : WS_VSCROLL);
  1091.     return (::SetWindowLong(hWnd, GWL_STYLE, dwStyle) != 0);
  1092. #endif // _WIN32_WCE_EMULATION
  1093.     return TRUE;
  1094. }
  1095.  
  1096. int wce_GetSystemMetrics(int nIndex)
  1097. {
  1098.     if(nIndex == SM_DBCSENABLED)
  1099.         return TRUE;
  1100.     else
  1101.         return GetSystemMetrics(nIndex);
  1102. }
  1103.  
  1104. void wce_SendWM_CREATEToDialog(HWND hWnd)
  1105. {
  1106.     CREATESTRUCT cs; // We "recreate" this by doing detective work.
  1107.     TCHAR szDummy[2];
  1108.  
  1109.     int nLen = GetWindowText(hWnd, szDummy, 1); // query len
  1110.     cs.lpszName = new TCHAR[nLen+1];            // create buffer
  1111.     if(cs.lpszName == NULL)
  1112.         return; // If this fails, forget it.
  1113.     GetWindowText(hWnd, (TCHAR*)cs.lpszName, nLen); // un-const cast
  1114.  
  1115.     cs.lpszClass  = new TCHAR[64];
  1116.     GetClassName(hWnd, (TCHAR*)cs.lpszClass, 64);
  1117.  
  1118.     cs.style = GetWindowLong(hWnd, GWL_STYLE);
  1119.     cs.dwExStyle = GetWindowLong(hWnd, GWL_EXSTYLE);
  1120.  
  1121.     cs.hwndParent = GetParent(hWnd);
  1122.     cs.hInstance = AfxGetInstanceHandle();
  1123.  
  1124.     RECT rectDlg;
  1125.     GetWindowRect(hWnd, &rectDlg);
  1126.     if(cs.hwndParent != NULL) // child window?
  1127.     {
  1128.         RECT rectParent;
  1129.         GetWindowRect(cs.hwndParent, &rectParent);
  1130.         OffsetRect(&rectDlg,-rectParent.left,-rectParent.right);
  1131.     }
  1132.     cs.x = rectDlg.left;
  1133.     cs.y = rectDlg.top;
  1134.     cs.cx = rectDlg.right-rectDlg.left;
  1135.     cs.cy = rectDlg.bottom-rectDlg.top;
  1136.     
  1137.     cs.hMenu = NULL;
  1138.     cs.lpCreateParams = 0; // We lost the real lParam when WM_CREATE got eaten by WinCE
  1139.  
  1140.     SendMessage(hWnd,WM_CREATE,0,(LPARAM)&cs);
  1141.  
  1142.     delete[] (TCHAR*)cs.lpszName;
  1143.     delete[] (TCHAR*)cs.lpszClass;
  1144. }
  1145.  
  1146. BOOL CALLBACK wce_FirstDlgProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  1147. {
  1148.     // This gets called only once--on the first message sent to the dialog window.
  1149.  
  1150.     // We don't own the dlgproc for property sheet, so we have to use the first message
  1151.     // for the first property page as our CBT Hook opportunity.  We fake the
  1152.     // missed WM_INITDIALOG hook.  MFC *will* handle this in dlgprop.cpp (a subset of
  1153.     // the original OnInitDialog implemention) and won't delegate back to the real
  1154.     // dlgproc for the property sheet (if it did, it'd be processing WM_INITDIALOG for
  1155.     // the second time.)
  1156.     _AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
  1157.     CWnd *pWnd = pThreadState->m_pWndInit;
  1158.     if(pThreadState->m_pWndInitPropertySheet != NULL)
  1159.     {
  1160.         HWND hWndPropertySheet = ::GetParent(hWnd);
  1161.         ASSERT(hWndPropertySheet != NULL);
  1162.         ASSERT(pThreadState->m_pWndInit != NULL);
  1163.  
  1164.         CWnd *pWndInitFirstPropPage = pThreadState->m_pWndInit;
  1165.         pThreadState->m_pWndInit    = pThreadState->m_pWndInitPropertySheet;
  1166.         _AfxCbtFilterHook(HCBT_CREATEWND, (WPARAM)hWndPropertySheet, NULL);
  1167.         pThreadState->m_pWndInit    = pWndInitFirstPropPage;
  1168.  
  1169.         ((CPropertySheet*)pThreadState->m_pWndInitPropertySheet)->OnInitDialog();
  1170.         pThreadState->m_pWndInitPropertySheet = NULL;
  1171.     }
  1172.  
  1173.     // Make sure the standard dialog box loop is the OS-owned one
  1174.     ::SetWindowLong(hWnd,GWL_WNDPROC,(LONG)::DefDlgProc);
  1175.  
  1176.     // Let MFC subclass the dialog procedure.
  1177.     if(!pWnd->IsKindOf(RUNTIME_CLASS(CCommonDialog)))
  1178.     {
  1179.         // Common dialogs have OS-owned dialog procedures.  That's why 
  1180.         // MFC hooks with _AfxCommDlgProc. We don't want this relationship broken.
  1181.         ::SetWindowLong(hWnd,DWL_DLGPROC,(LONG)AfxDlgProc); 
  1182.     }
  1183.     
  1184.     // Do normal WNDPROC subclassing now.  Note: after this call, m_pWndInit will
  1185.     // be NULL.  This is important in avoiding reentrancy via _AfxCommDlgProc.
  1186.     _AfxCbtFilterHook(HCBT_CREATEWND,(WPARAM)hWnd,NULL);
  1187.  
  1188.     // Delegate this message to the new subclassed WndProc
  1189.     WNDPROC afxWndProc = AfxGetAfxWndProc();
  1190.  
  1191.     // A nuance of WinCE: WM_CREATE on dialog boxes don't make it to the dialog procedure.
  1192.     // MFC depends on this on at least one count: the CFormView (which is a dialog) wants
  1193.     // to have its OnCreate() called.  Since we're at the actual first message, now 
  1194.     // is the best time to fake the WM_CREATE.  
  1195.     if( (pWnd != NULL) && (pWnd->IsKindOf(RUNTIME_CLASS( CFormView ) ) ) )
  1196.         wce_SendWM_CREATEToDialog(hWnd);
  1197.  
  1198.     // Repump the message through the entire chain.
  1199.     return afxWndProc(hWnd,nMsg,wParam,lParam);
  1200. };
  1201.  
  1202. #define WCE_CLASS_PREFIX _T("WCE_")
  1203.  
  1204. // Register a "hybrid" class (from the current one), substituting a new
  1205. // ClassName and WndProc.  This ensures that the first message is sent
  1206. // to wce_FirstDefWindowProc.
  1207. // NOTE: It is okay to "own" the ThreadState here because the baseline does 
  1208. //       something similar in AfxHookWindowCreate() with pThreadState->m_pWndInit.
  1209. BOOL wce_PreCreateWindow( CREATESTRUCT& cs)
  1210. {
  1211.     // Standalone menus are not supported in ::CreateWindowEx, so we need to filter it out.
  1212.     // We'll cache it later in wce_PostCreateWindow.
  1213.     if(HIWORD(cs.hMenu) != NULL)  // if it is a control ID, then its HIWORD == NULL
  1214.         cs.hMenu = NULL;
  1215.  
  1216.     _AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
  1217.  
  1218.     // Get the old class.  If it doesn't exist, then return FALSE.
  1219.     WNDCLASS wndclass;
  1220.     if (!GetClassInfo( cs.hInstance, cs.lpszClass, &wndclass))
  1221.         return FALSE;
  1222.  
  1223.     // Don't do anything with classes that begin with "Afx."  The 
  1224.     // wce_FirstDefWindowProc is already set for those in 
  1225.     // AfxRegisterClass() and AfxEndDeferRegisterClass()
  1226.     if(_tcsnicmp(cs.lpszClass,_T("Afx"),3) == 0)
  1227.     {
  1228.         pThreadState->m_pOldProc = ::DefWindowProc;
  1229.         // We leave cs.lpszClass alone
  1230.         return TRUE; // don't do anything on MFC windows
  1231.     }
  1232.  
  1233.     // Compose a new class name (e.g. "WCE_oldname"). We account for both
  1234.     // ways new might fail (exceptions vs. NULL ptr)
  1235.     TRY 
  1236.     {
  1237.         wndclass.lpszClassName = new TCHAR[_tcslen(cs.lpszClass) + 
  1238.                                            _tcslen(WCE_CLASS_PREFIX) + 1];
  1239.     } 
  1240.     CATCH_ALL(e) 
  1241.     {
  1242.         return FALSE;
  1243.     } END_CATCH_ALL
  1244.  
  1245.     if(wndclass.lpszClassName == NULL)
  1246.         return FALSE;
  1247.  
  1248.     _tcscpy( (TCHAR*)wndclass.lpszClassName, WCE_CLASS_PREFIX );
  1249.     _tcscat( (TCHAR*)wndclass.lpszClassName, cs.lpszClass );
  1250.                                                                               
  1251.     // Change the window procedure, saving the old one.
  1252.     WNDPROC OldProc      = wndclass.lpfnWndProc;
  1253.     wndclass.lpfnWndProc = (WNDPROC)wce_FirstDefWindowProc;
  1254.  
  1255.     // Register the new class (if not already registered)
  1256.     if (!AfxRegisterClass(&wndclass))
  1257.     {
  1258.         delete[] (void*)wndclass.lpszClassName;
  1259.         return FALSE;
  1260.     }
  1261.  
  1262.     // If successful, commit our change to pThreadState and cs.
  1263.     pThreadState->m_pOldProc = OldProc;
  1264.     cs.lpszClass = wndclass.lpszClassName;
  1265.  
  1266.     // Note: cs.lpszClass will be deleted in wce_PostCreateWindow
  1267.     return TRUE;
  1268. }
  1269.  
  1270.  
  1271.  
  1272. LRESULT CALLBACK wce_FirstDefWindowProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  1273. {
  1274.     // This gets called only once.  We first plug in the normal DefWindowProc (because
  1275.     // The hook will add it to the chain after plugging in AfxWndProc.)  And then we
  1276.     // delegate to AfxWndProc.
  1277.     // Note: it's possible that the ::CreateEx returns without a chance to call this.  That
  1278.     // case is taken care of after CreateEx (does the same thing here minus the message
  1279.     // delegation.)
  1280.  
  1281.     // Retrieve the old WndProc.
  1282.     _AFX_THREAD_STATE* pThreadState = _afxThreadState.GetData();
  1283.     ASSERT(pThreadState);
  1284.  
  1285.     // Retrieve MFC's WndProc
  1286.     WNDPROC afxWndProc = AfxGetAfxWndProc();
  1287.  
  1288.     // Set current WndProc to oldproc.  After the hook function is finished, then oldproc
  1289.     // will be installed as the m_pfnSuper.
  1290.  
  1291.     ASSERT(pThreadState->m_pOldProc != NULL);
  1292.     ::SetWindowLong(hWnd,GWL_WNDPROC,(LONG)pThreadState->m_pOldProc);
  1293.     pThreadState->m_pOldProc = NULL;
  1294.  
  1295.     // Fake the call to _AfxCbtFilterHook
  1296.     _AfxCbtFilterHook( HCBT_CREATEWND, (WPARAM)hWnd, NULL );
  1297.  
  1298.     // Delegate.
  1299.     return afxWndProc(hWnd,nMsg,wParam,lParam);
  1300. }
  1301.  
  1302.  
  1303. void wce_PostCreateWindow( CREATESTRUCT& cs, HWND hWnd, HMENU nIDorHMenu)
  1304. {
  1305.     // Check to see if the hook has been invoked (sometimes we can have no messages
  1306.     // sent right away, which means wce_FirstDefWindowProc hasn't gotten called yet.)
  1307.     _AFX_THREAD_STATE* pThreadState = AfxGetThreadState();
  1308.     if(pThreadState->m_pWndInit != NULL)
  1309.     {
  1310.         if(hWnd != NULL) 
  1311.         {
  1312.             ASSERT(pThreadState->m_pOldProc != NULL);
  1313.             ::SetWindowLong(hWnd,GWL_WNDPROC,(LONG)pThreadState->m_pOldProc);
  1314.             pThreadState->m_pOldProc = NULL;
  1315.             _AfxCbtFilterHook( HCBT_CREATEWND, (WPARAM)hWnd, NULL );
  1316.         }    
  1317.         else
  1318.         {
  1319.             pThreadState->m_pWndInit = NULL;  
  1320.             pThreadState->m_pOldProc = NULL;
  1321.         }
  1322.     }
  1323.  
  1324.     if(_tcsnicmp(cs.lpszClass,WCE_CLASS_PREFIX,4) == 0)
  1325.         delete[] (void*)cs.lpszClass; // from new in wce_PreCreateWindow
  1326.  
  1327.     // Set the menu (wce_SetMenu just caches it away in CWnd)
  1328.     if((hWnd != NULL) && (HIWORD(nIDorHMenu) != NULL))
  1329.         wce_SetMenu(hWnd, nIDorHMenu);
  1330. }
  1331.  
  1332.  
  1333. LRESULT CALLBACK wce_NullWndProc(HWND hWnd, UINT nMsg, WPARAM wParam, LPARAM lParam)
  1334. {
  1335.     // This window procedure is here to eat all messages after a window
  1336.     // has been detached.  The reason for this is that the WM_DESTROY
  1337.     // message below is "close" to being the last message, but we treat
  1338.     // it as such.  After that, we no longer have a CWnd->hWnd attachment,
  1339.     // so we use this WNDPROC to eat up any remaining messages.
  1340.     return 0;
  1341. }
  1342.  
  1343.  
  1344.  
  1345.  
  1346. // Workaround: the width of the property sheet is too big (with an error 
  1347. // proportional to the desired width). We correct for this here.
  1348. void wce_AdjustPropertySheetSize(CPropertySheet *pSheet)
  1349. {
  1350.     int nMaxWidth = 0, nMaxHeight = 0;
  1351.  
  1352.     ASSERT(pSheet->m_hWnd != NULL);
  1353.  
  1354.     for (int i = 0; i < pSheet->GetPageCount(); i++)
  1355.     {
  1356.         const DLGTEMPLATE* pTemplate;
  1357.         CPropertyPage* pPage = pSheet->GetPage(i);
  1358.         CSize size;
  1359.  
  1360.         if (pPage->m_psp.dwFlags & PSP_DLGINDIRECT)
  1361.         {
  1362.             pTemplate = pPage->m_psp.pResource;
  1363.         }
  1364.         else
  1365.         {
  1366.             HRSRC hResource = ::FindResource(pPage->m_psp.hInstance,
  1367.                 pPage->m_psp.pszTemplate, RT_DIALOG);
  1368.             HGLOBAL hTemplate = LoadResource(pPage->m_psp.hInstance,
  1369.                 hResource);
  1370.             pTemplate = (LPCDLGTEMPLATE)LockResource(hTemplate);
  1371.         }
  1372.  
  1373.         CDialogTemplate dlgTemplate(pTemplate);
  1374.         dlgTemplate.GetSizeInPixels(&size);
  1375.         if(size.cx > nMaxWidth)
  1376.             nMaxWidth = size.cx;
  1377.         if(size.cy > nMaxHeight)
  1378.             nMaxHeight = size.cy;
  1379.     }
  1380.  
  1381.  
  1382.     CTabCtrl* pWndTab = (CTabCtrl*)pSheet->GetDlgItem(AFX_IDC_TAB_CONTROL);
  1383.     if(pWndTab != NULL)
  1384.     {
  1385.         CRect rectWndTab, rectWndDlg;
  1386.  
  1387.         pSheet->GetWindowRect(rectWndDlg);
  1388.         pWndTab->GetWindowRect(rectWndTab);
  1389.         int dx = (rectWndTab.left-rectWndDlg.left) + 
  1390.                  (rectWndTab.right-rectWndDlg.right);
  1391.         int dy = (rectWndTab.top-rectWndDlg.top) + 
  1392.                  (rectWndTab.bottom-rectWndDlg.bottom);
  1393.  
  1394.         CRect rectDisplayTab = rectWndTab;
  1395.         pWndTab->AdjustRect(FALSE,&rectDisplayTab);
  1396.         int nButtonHeight = rectDisplayTab.top-rectWndTab.top;
  1397.         int nHSlop = 2;
  1398.         int nVSlop = 12;
  1399.  
  1400.         int nWidth  = nMaxWidth  + 
  1401.             ::GetSystemMetrics(SM_CXEDGE)*2 +
  1402.             ::GetSystemMetrics(SM_CXDLGFRAME)*2 + nHSlop;
  1403.         int nHeight = nMaxHeight + nButtonHeight + nVSlop + 
  1404.             ::GetSystemMetrics(SM_CYEDGE)*2 + 
  1405.             ::GetSystemMetrics(SM_CYDLGFRAME)*2 +
  1406.             ::GetSystemMetrics(SM_CYCAPTION);
  1407.  
  1408.         pSheet->SetWindowPos(NULL, 0, 0, nWidth, nHeight,
  1409.                               SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  1410.         pWndTab->SetWindowPos(NULL, 0, 0, nWidth - dx, nHeight - dy,
  1411.             SWP_NOMOVE | SWP_NOZORDER | SWP_NOACTIVATE);
  1412.     }
  1413. }
  1414.  
  1415. #if !defined(_WIN32_WCE_NO_WININET)
  1416. BOOL wce_InternetSetOptionEx(HINTERNET hInternet, DWORD dwOption,
  1417.                              LPVOID lpBuffer, DWORD dwBufferLength, DWORD)
  1418. {
  1419.     return InternetSetOption(hInternet, dwOption, lpBuffer, dwBufferLength);
  1420. }
  1421. #endif // _WIN32_WCE_NO_WININET
  1422.  
  1423.